Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/jdk.astub`:
- Around line 24-33: The import of java.io.IOException is redundant because this
stub is already in package java.io; remove the line importing
java.io.IOException from the file containing the Closeable interface (the file
declaring interface Closeable and method close(`@GuardSatisfied` Closeable this)
throws IOException) so the code relies on the package-visible IOException;
verify no other external imports are required and run cleanup to ensure no
unused-import warnings remain.

In `@checker/tests/resourceleak/sideeffect-free-stubs/AutoCloseableClose.java`:
- Around line 18-29: The test AutoCloseableClose.java has the same risky pattern
as CloseableClose.java: in the close() method (annotated with
`@EnsuresCalledMethods`(value={"this.first","this.second"}, methods="close")) a
call to first.close() can throw and prevent second.close(), violating the
exceptional postcondition; update the test by either adding the expected error
annotation (e.g. "// :: error: contracts.exceptional.postcondition") on the
method or before the close() implementation to mirror CloseableClose.java, or
add a short comment in the file explaining why this case is intentionally
different and does not produce the same error, referencing the method close(),
and the fields first and second so the intent is clear.

In `@checker/tests/resourceleak/sideeffect-free-stubs/CloseableClose.java`:
- Around line 24-27: Update the error annotation on the close() method to use
the canonical square-bracket format: change the comment token `// :: error:
contracts.exceptional.postcondition` to `// :: error:
[contracts.exceptional.postcondition]` so it matches the pattern used in
TwoResourcesECM.java and other tests.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/log4j.astub`:
- Around line 1-19: The stubs only declare debug/warn/error but miss other
common side-effect-free logging methods, causing inconsistent checker behavior;
update the org.apache.log4j.Logger class and org.apache.logging.log4j.Logger
interface to also declare `@SideEffectFree` methods info(Object), trace(Object),
fatal(Object) and the corresponding overloads info(Object, Throwable),
trace(Object, Throwable), fatal(Object, Throwable) so all common log-level
methods (both single-arg and Object+Throwable overloads) are treated as
side-effect-free by the checker.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/log4j.astub`:
- Around line 35-36: The stub methods like trace(Message message) and
trace(Message message, Throwable throwable) (and the corresponding overloads for
debug, info, warn, error, fatal) use an unqualified Message type which doesn't
resolve; update each parameter type from Message to the fully-qualified
org.apache.logging.log4j.message.Message in those method signatures (e.g.,
trace, debug, info, warn, error, fatal overloads) so the stub binds correctly
and `@SideEffectFree` can be applied.

In `@checker/tests/resourceleak/sideeffect-free-stubs/Log4j2ObjectCalls.java`:
- Around line 12-22: Add a regression test that exercises the Logger
throwable-overload to cover the stubbed (…, Throwable) mapping: call the
error(String, Throwable) overload (for example error("after close", new
RuntimeException())) in the same test file/class where object and varargs paths
are exercised (Log4j2ObjectCalls and the related tests around lines 54–112) so
the throwable-specific stub/mapping is invoked and protected from regressions.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/log4j.astub`:
- Around line 6-25: The new astub adds extra untested overload families
(Category.log(...), trace(...), fatal(...), and Log4j2 Message overloads) so
regressions or binding typos there won't be caught; update the tests to exercise
these newly stubbed signatures (or add new test cases similar to
checker/tests/resourceleak/sideeffect-free-stubs/Log4j1ObjectCalls.java and
Log4j2ObjectCalls.java) to cover Category.log(Priority,...),
Category.log(String,Priority,...), Logger.trace(...), Category.fatal(...), and
any Message-based overloads so the checker validates the bindings for those
methods as well. Ensure the tests include both object and throwable/varargs
paths for each added overload family to detect binding mistakes.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/jdk.astub`:
- Around line 16-19: Remove the redundant access modifier from the
Closeable.close declaration: in the interface Closeable (the method annotated
with `@SideEffectFree` and taking `@GuardSatisfied` Closeable this and throwing
IOException) drop the explicit "public" so the method matches the
implicit-public style used by AutoCloseable.close for consistency.

In
`@checker/tests/resourceleak/sideeffect-free-stubs-tests/ClosableResource.java`:
- Around line 1-14: The header comment and one helper class are misspelled:
rename the file to CloseableResource.java, correct the header comment to
"Closeable and AutoCloseable", and rename class AutoClosableResource to
AutoCloseableResource (keeping CloseableResource as-is); then update all
references/usages of AutoClosableResource (e.g., in AutoCloseableClose and any
other tests) to the new class name so compilation succeeds.

In
`@checker/tests/resourceleak/sideeffect-free-stubs-tests/Log4j2ObjectCalls.java`:
- Around line 11-81: Consolidate the six near-identical test classes
(Log4j2DebugObject, Log4j2DebugVarargs, Log4j2InfoObject, Log4j2WarnObject,
Log4j2ErrorObject, Log4j2ErrorWithThrowable) into a single test class (e.g.,
Log4j2ObjectCalls) that holds the `@Owning` CloseableResource field and exposes
multiple close-like methods (e.g., closeDebug(), closeDebugVarargs(),
closeInfo(), closeWarn(), closeError(), closeErrorWithThrowable()) each
annotated with `@EnsuresCalledMethods`(value = "this.resource", methods = "close")
and calling resource.close() followed by the respective logger call; this keeps
coverage for each logging variant while removing duplicate classes and
preserving the same logger usage and annotations.
- Around line 1-3: Update the file header comment to correct the broken sentence
and reflect that the Log4j stubs are no longer RLC-specific: rewrite the first
two lines so they read clearly (e.g., "This test covers the Log4j 2.x API in
package org.apache.logging.log4j; it uses the real library API.") and change the
second sentence to state that the Log4j stubs now live under
framework/src/main/java/org/checkerframework/framework/stub/jdk.astub and
therefore apply to all checkers (remove any mention of "RLC-specific"). Ensure
the new comment is concise and accurate and replace the existing erroneous
lines.

In `@framework/src/main/java/org/checkerframework/framework/stub/jdk.astub`:
- Around line 24-27: The Logger class members are indented with 4 spaces while
Category members use 2 spaces; update the indentation of the Logger member
declarations in class Logger (the two `@SideEffectFree` trace(...) lines) to use
2-space indentation to match Category for consistent formatting.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/tests/resourceleak/sideeffect-free-stubs-tests/CloseableResource.java`:
- Around line 1-2: Fix the typos in the file header comment for the
CloseableResource class: change "reources" to "resources" and "Autocloseable" to
"AutoCloseable" so the comment correctly reads that the class represents
resources that implement Closeable and AutoCloseable for use by other tests.

In `@framework/src/main/java/org/checkerframework/framework/stub/jdk.astub`:
- Around line 1-6: Update the header comment in
framework/src/main/java/org/checkerframework/framework/stub/jdk.astub to explain
why this non-JDK content is named jdk.astub and loaded globally: state that
AnnotationFileElementTypes.parseStubFiles() auto-discovers this file for all
checkers (the mechanism used to achieve framework-level global loading without
per-checker wiring). Also document the semantic limitation: that methods (e.g.,
Log4j APIs in package org.apache.log4j) are annotated `@SideEffectFree` for
practical flow-refinement reasons but this is a pragmatic/lenient choice because
logging produces external I/O; advise maintainers they can override in
checker-specific stubs if stricter I/O/purity semantics are needed.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In
`@checker/src/main/java/org/checkerframework/checker/rlccalledmethods/log4j.astub`:
- Around line 1-5: Add a short header comment to the top of the log4j.astub file
documenting that the `@SideEffectFree` annotations are a deliberate, RLC-only
compromise (logging performs I/O) and that this stub is intentionally loaded
only via RLCCalledMethodsChecker.@StubFiles (not as a framework-level stub) to
avoid accidental removal or promotion; mention the rationale from the discussion
with `@mernst` / `@kelloggm` so future maintainers understand why the annotation and
restricted scope are required.